{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * revised and tuned configuration, updated views\n",
    " * training on full dataset (including Y3, new light curves, fixes)\n",
    " * trained with updated star radius estimations, multiple duplicates removed\n",
    " * removed instar examples\n",
    "Bugfixing:\n",
    " * fix in weight calculation to have more weight on examples without full consensus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/rev_tuned_35_run_2/1/AstroCNNModel_revised_tuned_20220329_012446',\n",
       " '/mnt/tess/astronet/checkpoints/rev_tuned_35_run_2/2/AstroCNNModel_revised_tuned_20220329_013119']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/rev_tuned_35_run_2'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-35-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v12-val.csv'\n",
    "\n",
    "nruns = 2\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "2461 records\n",
      "Running model 2\n",
      "2461 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_e', 'disp_n', 'disp_j', 'disp_s', 'disp_b']\n",
    "\n",
    "col_e = labels.index('disp_e')\n",
    "thresh = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_e')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "for l in labels:\n",
    "    tce_table[l] = tce_table[l[:-1] + l[-1].upper()]\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9538461538461539\n",
      "Precision: 0.8701754385964913\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_e_p'] > 0)\n",
    "pos = (pl['disp_e'] > 0)\n",
    "\n",
    "pneg = (pl['disp_e_p'] == 0)\n",
    "neg = (pl['disp_e'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104485403\n",
      "369264198\n",
      "28484801\n",
      "1715064237\n",
      "199661915\n",
      "141753278\n",
      "158159741\n",
      "276978548\n",
      "340104253\n",
      "404220255\n",
      "377325711\n",
      "393324927\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "416282321\n",
      "277848886\n",
      "278555119\n",
      "116498176\n",
      "192591652\n",
      "450006142\n",
      "127846210\n",
      "261814771\n",
      "269291226\n",
      "408945155\n",
      "56861756\n",
      "101496204\n",
      "122577745\n",
      "238829802\n",
      "281543210\n",
      "335588842\n",
      "842068824\n",
      "1254504863\n",
      "91987762\n",
      "154271808\n",
      "159636125\n",
      "230197530\n",
      "284266496\n",
      "22892207\n",
      "291374558\n",
      "293328926\n",
      "311103813\n",
      "31868634\n",
      "320356995\n",
      "326693475\n",
      "373919592\n",
      "404851966\n",
      "40602499\n",
      "407615704\n",
      "41256189\n",
      "14209654\n",
      "188258751\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 340066802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e_p</th>\n",
       "      <th>disp_n_p</th>\n",
       "      <th>disp_j_p</th>\n",
       "      <th>disp_s_p</th>\n",
       "      <th>disp_b_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e_p, disp_n_p, disp_j_p, disp_s_p, disp_b_p, maxcount, disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 340066802]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_e']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = int(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9716394997657267, max R: 1.0, max P: 1.0\n",
      "100% recall at: 12%, threshold: 2.1255493218633875e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    ps.append(p)\n",
    "    rs.append(r)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
